/**
	This file is part of MemoryTrace.

	MemoryTrace is free software: you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation, either version 3 of the License, or
	(at your option) any later version.

        Written by Ameziane NAIT ABDELAZIZ.
        
	MemoryTrace is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with MemoryTrace.  If not, see <http://www.gnu.org/licenses/>.
**/

/** 
 * !\file   CompressorProcess.h
 *  \brief  Code exécuté par le porcessus instrumenteur
 */

#ifndef COMPRESSORPROCESS_H
#define	COMPRESSORPROCESS_H


#include <queue>
#include <cstdio>
#include <pthread.h>
#include <list>

#include "../stack_trace/stack_trace.h" //utilisation des routines de demangling
#include "alloc_event_t.h"              //utilisation de la structure événement d'allocation 


using namespace std;

/**
 * \brief Une structure de données regroupant un fragment de trace mémoire.
 */
typedef struct {
    
    /**
     * \brief
     */
    void * content;
    
    /**
     * \brief
     */
    long  events_count;
}trace_part;
/*------------------------------------------------------------------------*/


/*Une classe pour executer du code d'instrumentation                      */
/*------------------------------------------------------------------------*/

class CompressorProcess {
  
  
 private:
  
  /**
   * \brief un pointeur vers la shared memory.
   */
  char* shmem_events;

  /**
   *Un pointeur vers une shared memory et une liste d'éléments.
   */
#ifndef WITH_PTHREADS
  char* shmem_stacktraces;
  list<callers_tree*> stack_traces_demangled;
#endif
  
  unsigned long* shmem_events_count;
  
    /**
     * \brief Fichier ou écrire les stack traces.
     */
    FILE* stack_traces_pipe;
    
    /**
     * \brief la zone mémoire qui contiendera la trace en entier.
     */
    char* trace_inmem;
    
    /**
     * \brief La taille actuelle de la trace mémoire.
     */
    size_t trace_size;
    
    /**
     * \brief La taille actuelle de la stack trace mémoire.
     */
    size_t stacktrace_size;
    
    
    //@ Attention; il faudra virer ceci, car on va mettre du TBB et du pipline
    /**
     * \brief Un thread utilisé pour lire les back trace
     */
    pthread_t btrace_reader;

    
public:
    /**
     * \brief Initialise les données locales.
     */
    CompressorProcess();
    
    /**
     * \brief
     * @param orig
     */
    CompressorProcess(const CompressorProcess& orig);
    
    
    /**
     * \brief
     */
    virtual ~CompressorProcess();
    
    
private:
    
    /**
     * \brief Le processus appelant copie le contenu de la shared memory dans son espace d'adressage.
     */
    void copyToLocalMemoryShmemContent(long count);
    
public:
    /**
     * \brief Initalise la communication inter-processus.
     */
    void initIPC();
    
    /**
     * \brief Finalise la communication inter-processus.
     */
    void finitIPC();
    
    
    /**
     * \brief Opérateur qui renvoie le ieme fragment de trace mémoire.
     */
    
    alloc_event_t* operator [](size_t i);
    
    /**
     * \brief Commence la boucle de communication.
     */
    void startWork();
    
    /**
     * \brief Ecrit le contenu de la trace mémoire sur le disque dur.
     */
    void writeMemoryTraceToFile();
    
    
    /**
     * \brief Copie le contenu de la shared memory dans la mémoire locale.
     */
    void copyToLocalMemoryStackTraces(long count);
    
    /**
     * \brief Ecrit la backtrace sur le disque dur.
     */
    void writeBacktracesToFile(bool yes_or_no);
};

#endif	/* COMPRESSORPROCESS_H */

